The easiest way to see the distinction is by an analogy with 'virtual fns': A virtual member fn means the declaration (signature) must stay the same in subclasses, but the defn (body) can be overridden. The overriddenness of an inherited member fn is a static property of the subclass; it doesn't change dynamically throughout the life of any particular object, nor is it possible for distinct objects of the subclass to have distinct defns of the member fn.
Now go back and re-read the previous paragraph, but make these substitutions:
'member fn' --> 'subobject'
'signature' --> 'type'
'body' --> 'exact class'
After this, you'll have a working defn of virtual data.
'Per-object member fns' (a member fn 'f()' which is potentially different in any given instance of an object) could be handled by burying a function ptr in the object, then setting the (const) fn ptr during construction.
'Dynamic member fns' (member fns which change dynamically over time) could also be handled by function ptrs, but this time the fn ptr would not be const.
In the same way, there are three distinct concepts for data members: * virtual data: the defn ('class') of the subobject is overridable in subclasses provided its declaration ('type') remains the same, and this overriddenness is a static property of the [sub]class. * per-object-data: any given object of a class can instantiate a different conformal (same type) subobject upon initialization (usually a 'wrapper' object), and the exact class of the subobject is a static property of the object that wraps it. * dynamic-data: the subobject's exact class can change dynamically over time.
The reason they all look so much the same is that none of this is 'supported' in C++. It's all merely 'allowed', and in this case, the mechanism for faking each of these is the same: a ptr to a (probably abstract) base class. In a language that made these 'first class' abstraction mechanisms, the difference would be more striking, since they'd each have a different syntactic variant.
